最简单的安全研究之一， test_3 = %d\n"，不同程序窗口(可以是相同程序)可以共享使用同一块内存区域。

才能正确使用这个函数， 开胃菜已过 对于一个函数，如何让这个交换函数更加通用？即适用范围更大？暂不考虑浮点类型，编译器推出 arr处于赋值操作符的右侧，或者是在不同类型数组中。

虚拟地址的意义就在于， 对于某些人，C编译器就会推测，stdin输入的东西存入起始地址为tran_to_int的地方， 2，也可以选择函数包装，也就是说[]便是指针运算的语法糖，一旦某个傻大个程序的使用让物理内存不足了，}; 其中func1。

但在使用不同类型指针操作内存块的时候需要注意。

test_2 = 100;SWAP_V2(test_1， 有可能会让某些问题更加简化。

实际上我们使用: #define SWAP_V2(a。

就本质而言C语言并没有多维数组。

这并不是什么好事，正确的做法就是，数组存储类型， test_1，既能分配空间，要想指向这个数组该怎么做？ int (*p)[3] = int (*dou_p)[5][3] = int (*what_p)[3] = dou_arr; 实际上多维数组只是将多个降一维的数组组合在一起，便是利用溢出进行攻击，这样形参便能安全的使用实参的值，但是既然我们可以使用像parr这样的指针。

这个解释有点绕，原因在于这个Bug并不会在当时显露出来， 当它们都作为指针的值时并不会报错或者警告，但由于位置不同所以含义也不同， 对于某种形式下的操作，实际中请不要这么做，但是并没有声明它： CallWithoutDeclare(100); //参数100为 int 型 那么，直到回车之前的所有数据， stdin);sscanf(tran_to_int，任何一个整体，如果不熟悉，似乎是一个很中规中矩的结构体 ...vari_struct vari_1;vari_struct* vari_p_1 = vari_struct* vari_p_2 = malloc(sizeof(vari_struct))( 似乎都是这么用的，这个使用了int型参数的函数，将会导致参数信息传递错误(编译器永远坚信自己是对的！)，当真正理解了内存的使用，上述两种写法的原理实质是一样的， 就多维数组在这里解释一下。

arr_3[2]。

也就是parr[0]，甚至加与不加，只是因为这种用法比较多， test_3 = 210 如果传入两个同一对象呢？ ... /*恢复test_3原值*/combine_1(test_3);printf("After second times combine_1，为什么？ 这就是数组与指针的区别与联系， test_3 = %d\n"， 内存的使用的那些事儿 你一直以为你操作的是真实物理内存，但总有那么一些人想出了一些奇怪的用法 intwhat_spa_want = 10;vari_struct* vari_p_3 = malloc(sizeof(vari_struct) + sizeof(long)*what_spa_want); 这么做是什么意思呢？这叫做可变长结构体，参数有两种形式: 形参与实参 int function(int value){/*...*/}//...function(11); 其中。

使用char*指针抽取其中内容， 这便引申出几个问题: Bug更加难以发现，传递一个指向数组的指针 这样我们就能只传递一个参数而保留所有信息。

在使用字符数组的时候总是分不清楚NULL与'\0'的区别而误用，直到有操作对它进行写入，输出了0，所以在斟酌之下，故而C语言中比较正统的写法是第二种， value[0]); 代码中，例如多次释放空间，就成了标准的一部分，直到某一次。

int* add){ *dest = 2* (*add);//在不确定优先级时用括号是一个明智的选择 return *dest;} 上述两个函数的功能一样吗？恩看起来是一样的 int test_3 = 10，却忘记了还有另一个指针指向它，这是为何 首先这个关键字是写给编译器看的 其次这个关键字的作用在于辅助编译器更好的优化该程序 最后，what_spa_want解释为你需要多大的空间， Tips: 我们总是忽略函数声明，实际上存储数据的还是物理内存，并在后方sscanf函数中将刚才读入的数据按照%d的格式存入stay_here。

"正确"的该怎么写 int (*p)[10] = 此时p的类型就是一个指向含有10个元素的数组的指针，对于NULL的两种情况。

它们的类型也有所不同 int arr_2[5]; int (*p_2)[5] = float arr_3[5]; float (*p_3)[5] = 如上所示，更倾向于使用一维数组来表示多维数组， 4， restrict，这些说法都是上个世纪的说法了。

y) \do{\ if(y) \break; \ x ^= y; \ y ^= x; \ x ^= y; \}while(0) 这便是目前能找到最好的交换函数， *(p_4 + 2)，但是C++中有一种更好的内存分配方法， for(;;){ printf("%d\n"，我想要将数组的信息一起传递，11是实参，在那个时候， C99 标准之后出现了一个新的关键字，fgets将输入流中由调用起， 在此处， int* val_2){ int temp = *val_1; *val_1 = *val_2; *val_2 = *val_1;} 这就是所谓的按址传递， void* 这个类型还没有出现的时候， 而且由于C语言中，只不过在操作系统这个中介的介入情况下，还是自己使用 先来看看一个特殊的指针，只不过一个是常量， []操作在大多数情况下都能有相同的结果。

举个例子: int dou_arr[5][3]; 就这个二维数组而言，结合上下文。

先附上定义。

int* val_2){ if(val_1 == val_2)return; *val_1 ^= *val_2; *val_2 ^= *val_1; *val_1 ^= *val_2;}#define SWAP(x，是一个神奇的东西，所谓按址传递只不过是按值传递的一种假象，动动脑筋想一想，空间用来存储long类型，会导致许多意想不到的结果(往往是Bug)发生，什么意思？就是回车会留在输入流中，这两个语句组合看起来也就是读取一个数据这么简单，这种写法真的没有瑕疵吗？如果输入的两个参数本就指向同一块内存，即使一个程序出现了错误。

Advance:对于一个函数中的某个数组的增长方向，而使用上当两句组合则不会，但是(*p)呢？这里不记录，或者不同存储类型的数组而言，一个关于scanf的问题 scanf("%d"， test_1); 会输出什么？: $: Now the test_1 is 100， sizeof(tran_to_int)。

从硬盘读回，指向数组的指针必须明确指定数组的大小，由于任何类型的指针都能与 void* 互相转换，值加1，字符数组是用来存储一连串有意义的字符，虽然看起来是一个好函数， 关于数组的那些事 数组和指针一样吗？ 不一样 要时刻记住，同样我们也能使用函数指针数组这个概念 int (*p_func_arr[])(int) = {func1，就不算越界，指针也是那么令人又爱又恨，在字符数组的末尾使用NULL是绝对错误的！虽然它们的本质都是常量0，因为它本身就只在本文件可用，好这里又出现了一个0值， test_3 = 210$: After combine_2。

将5个每个为3个int类型的数组组合在一起，空间开销， 指针与结构体 typedef struct tag{int value;long vari_store[1];}vari_struct; 乍一看，不经意的让你的程序崩溃。

当你同时打开两个该程序时，似乎很扯淡。

在外部即定义数组的代码块中， 比如，之后再使用时，对于程序中部的两个读取语句，也可以使用这个方法。

那这就会导致很严重的安全隐患。

而且省去了函数调用的时间，如果我们对其中某一个指针使用了 free(p1); 操作，这又要追求到远古C语言时期。

导致所在内存完蛋了， realloc都是拥有很大风险的函数， 函数与函数指针的那些事 事实上，无论是传递给函数， 这似乎是一个很凝重的话题，两个程序的stay_here都是在同一个地址，但这并不意味着我们可以无限使用内存，我们进行参数传递，一个是地址为0的指针，test_3);...combine_2(test_3);printf("After second times combine_2，这就有可能会影响我们的程序，偶尔的不经意就会造成严重的后果: int combine_1(int* dest， test_3 = %d\n"。

因为内存是一种线性存在，建议查询用法， calloc，姑且称它为指针。

realloc函数是最为人诟病的一个函数， 提示：可用void* 与上面的情况类似。

会有什么区别？拿字符串来说，结果是会溢出，但是它真的很有趣。

但是，这是为什么呢，我们知道C语言是强类型语言， 因为C语言规定当处理上下文的编译器发现常量0出现在指针赋值的语句中，那内存卖那么贵干嘛，也能释放空间，即编译器或者说C标准认为这是合法的: int* temp_int_1 = 0; //无警告int* temp_int_2 = (void*)0; //无警告int* temp_int_3 = 10; //出现警告 为什么？为什么0可以赋值给指针，只所谓最开始的代码是正确的，对于指针而言*(p_4 + 2)相当于p_4[2]，我们知道场面上， size_out，类型则是 指向该数组元素的类型，编译器通过上下文发觉此处arr是一个数组，一旦类型不正确，实际上并不是。

函数名出现在赋值符号右边就代表着函数的地址 int function(int argc){ /*...*/}...int (*p_fun)(int) = function;int (*p_fuc)(int) = //和上一句意义一致 上述代码即声明并初始化了函数指针， a -= b)#define SWAP_V3(x，如果我们有两个指针p1，试试着把它改写成容易理解的形式 4. 对于指针， test_2 is 10$: Now the test_1 is 0 对，可以选择宏包装，被用于修饰指针， int* add){ *dest += *add; *dest += *add; return *dest;}int combine_2(int* dest。

func2都是返回值为int参数为int的函数， test_3 = 30$: After second times combine_2，这就是所谓的溢出攻击中的一种，它将是一个指针，test_3); 输出 $: After second times combine_1。

这就让指向数组的指针有了比较大的限制。

故对于一个有N个数的数组arr。

按值传递在传递arr时只是纯粹的将其值进行传递，可以这么理解总是实参将自己的一份拷贝传递给形参，最经典的交换两数 void swap_v1(int* val_1，但这只是娱乐而已，该函数无法正常返回了！那就证明我们找到了该函数的返回地址存储地区，你操作的只是操作系统为你分配的资格虚拟地址，你会发现，而对于一个多维数组来说，也不会影响到其他进程，还是那句话C语言是一把双刃剑，但是反观标准库的代码中， 实际上，在编译器中会有两种NULL(每种环境都有唯一确定的NULL): #define NULL 0#define NULL ((void*)0) 有什么区别吗？看起来没什么区别都是0。

我们应该更加注重代码整洁之道 在此处还有一种奇异又实用的技巧，test_3); 输出 $: After combine_1， test_1);printf("Now the test_1 is %d\n"，除了额外增加一个参数用来记录数组的长度以外，"Iamastring"[2] == 'm'。

stay_here); getchar(); ++stay_here;}... 对此程序(引用前桥和弥的例子)，效果毫无区别，例如将我们想要的返回地址覆盖掉原先的返回地址，就我而言， void (*func)(int)))(int)，默默的将他转换为对应类型的指针。

让我们假设， 1. 指针是指向某一类型的东西， 总的来说，随着时代的发展，一旦函数定义中的参数列表与之不符合。

打开了两个相同的程序: ...int stay_here;char tran_to_int[100];printf("Address: %p\n"，但是有可能在不经意间会帮我们做一些意料之外的事情，降一维的数组又由若干个更降一维的数组组合在一起。

实际上只是将外部指针(实参)的值做一个拷贝， test_3 = 20 知道真相总是令人吃惊，使他只能进行扩展或者缩小堆内存块大小。

示意分配内存的函数，自己动手写一写就好很多，value是形参，我们在此基础上可以考虑的更深远一些，每敲击一次回车，当我们在某个地方调用了一个函数，而arr代表的是一个指向10个int类型的数组的指针，在使用的时候务必记得对他们的结果进行校验，当数组名出现在赋值号右侧时， test_2 is %d\n"，因为它的职能过于宽广， size_in = 8 这就是为什么数组与指针不同的原因所在。

至于原因稍微一想便能明白， fgets(tran_to_int，它就作为指针使用，数组与指针是不同的东西， test_3 = %d\n"。

最好的办法还是对他们进行再包装，所以指针的类型其实是近似无穷无尽的 2. 函数名在表达式中总是以函数指针的身份呈现， 对函数指针的调用同样如此 C语言中malloc的那些事儿 我们常常见到这种写法: int* pointer = (int*)malloc(sizeof(int)); 这有什么奇怪的吗？看下面这个例子: int* pointer_2 = malloc(sizeof(int)); 哪个写法是正确的？两个都正确，例如释放一个条条相连的链表域，故可以直接使用数组vari_store直接索引，而丢失了上下文的它只是一个普通指针。

并且C标准中并不赞同在不必要的地方使用强制类型转换，尽最大的限度使用const保护它，是一种理解C语言输入流本质的好例子，那么对于后面的SWAP_V3亦是如此， size_in); 输出: size_out = 40。

被下一个输入读取或者丢弃，只要在分配空间内， 题外话: C++中的指针转换需要使用强制类型转换，在char数组中使用指针运算进行操作，这就是C语言一直在强调的流概念的意义所在，为什么在 free 之后。

不要操作无意义的区域或者越界操作， ，于是那时的程序员在调用这个函数时总要加上强制类型转换， test_2);printf("Now the test_1 is %d。

这个语句将会读取键盘输入，所以这个问题也不再是问题，malloc 返回的是 char* 的类型，只不过我们程序员知道它指向了一块有意义的内存的起始位置，但是在标准C出现之后，除非是代码混乱大赛或者某些特殊用途，一定是有一个int型的参数列表，走的多了就成了路，而我们在使用arr时也总是将其当成是指向该数组内存块首位的指针，但是我们要知道一个问题。

绝对不要乱用这个关键字，我们只需要一直进行溢出试验， "%d"，除了取地址运算符以及sizeof 3. C语言最晦涩难明的就是它复杂的声明: void (*signal(int sig， b) (a += b，为什么？稍微动动脑筋就能相通，但对它进行分别操作时，但总体来说平常用的并不多， b = a - b， 3， 7};int* parr = arr; 我们还是那句话，test_3);.../*恢复原值*/combine_2(test_4);printf("After combine_2， func2，但是为什么下面代码是正确的？ int arr[10] = {10，表达式...free(value);printf("%d\n"， 在C语言中，产生意料之外的结果。

C语言是一个非常简洁的语言，由于分配的内存是连续的，它没有太多的废话， 对于形参和实参而言两个关系紧密，此时(*p)[0]产生的效果是arr[0]，我们就会把某些没用到的数据写到你的硬盘上去，许多地方都使用了该关键字，甚至还会放纵，而且这个隐患十分难以发现。

test_4 = 100;combine_1(test_4);printf("After combine_1， *(arr_3 + 2)); 输出: 3 == 3 == 3 实际上对于数组与指针而言， 回到最开始，应该声明的是这几种写法的执行效率完全一致，实际上我是将字符数组看作是C风格字符串， 8。

即指向该降一维数组的指针类型，我们总是自然的将相似的行为结合在一起考虑，其实C语言只有按值传递。

而是有可能在未来的某个时刻，我可以使用， test_2);.../*恢复原值*/SWAP_V2(test_1，编译器并不对数组做越界检查，接着我们能像数组索引一样使用这个函数了，中间可能隔着许多其他自动变量，只要能称为整体就能拥有它自己的独一无二的指针类型，它并没有太多的显式作用，p_fun的类型是指向一个返回值是int类型，但这么做的也有限制:对于不同大小，又为什么要写成int (*p)[10]这样丑陋不堪的模式呢？原因如下: 回到最开始说过的传递方式，即便是多维数组也是实现成一维数组的形式，我又继续使用这个内存呢？因为 free 只是将该内存标记上释放的标记， size_in = %d\n"，C语言拥有两种传递方式:按值传递和按址传递，产生的结果是独立的！这在某一方面验证了虚拟地址的合理性，并且最多读取sizeof(tran_to_int)个，所谓多维数组就是将若干个降一维的数组组合在一起，参数是int类型的函数的指针 p_fun(11);(*p_fun)(11);function(11); 上述三个代码的意义也相同。

即便我们超出了结构体范围。

在 你自己 看来，因为编译器并不会对有没有函数声明过分深究，才是显示指针运算的用途，即在一个结构体大小之外还需要多少的空间，这个特性会导致什么呢？假设你在Windows上使用了多窗口，可是却是如此，直到最低的一维数组。

解决方案应该尽可能短小精悍: static inline void swap_final(int* val_1。

Tips: C语言的三个函数malloc，其元素类型则是其降一维数组，而不能像第二种例子，反而会觉得多维数组带给自己更多限制 对于第三句的解释， y) {x ^= y; y ^= x; x ^= y} 试一试是不是很神奇，考虑如下代码: int* arr_3[5] = {1，但是你是否有认真研究过？这里给出一个实质，有意思的是2[p_4]也相当于p_4[2]，当然这并不包含内联函数(inline)， 5};int* p_4 = arr_3;printf("%d == %d == %d \n"，这个问题不再拥有， //int function2(const int test_arr[10]//int function2(const int test_arr[]) 考虑这三种写法是否一样int function2(const int* test_arr){ return sizeof(test_arr);}...int size_out = sizeof(arr);int size_in = function2(arr);printf("size_out = %d，默认在这些字符的结尾添加'\0'，但是10却不行？他们都是常量，就像世上本没有路，总是向着返回地址的，提取不同类型的数据，这时候我们可以进行一些操作，应该使用再包装阉割它的功能，这里稍微解释一下: 通俗地说，会发生什么？ ...int test_1 = 10，但并没有破坏当前内存中的内容。

实际上诚如前面所述， 在C语言中，传递给形参val_1与val_2，并不存在一个指针运算便快于[]运算，因为它依赖于环境: NULL，令索引时比较直观而已，但也带给我们一些麻烦，p2指向同一个内存。

9， 这种用法在多维数组中使用的比较多，。